<template>
    <div
        class="businessSystem-container"
        v-loading="pageLoading"
        element-loading-background="rgba(255, 255, 255, 0.7)"
    >
        <div class="businessSystem-userinfo" v-if="false">
            <div class="box-group text_fl">
                <p class="title">
                    是否验密通过：
                    <span>
                        {{
                        checkData.passwordCheckFlag ? "是" : "否"
                        }}
                    </span>
                </p>
                <div class="line"></div>
                <div class="content">
                    <el-row>
                        <el-form
                            ref="formData"
                            :model="formData"
                            :rules="rules"
                            label-width="150px"
                        ></el-form>
                    </el-row>
                </div>
            </div>
        </div>
        <!-- v-if="isShowLogin" -->
        <div class="businessSystem-wrap">
            <div class="businessSystem-box businessSystem-left" ref="businessSystem_left">
                <div id="mainLeft" ref="mainLeft" class="businessSystem_mainLeft">
                    <base-info></base-info>
                    <account-title></account-title>
                    <order ref="orderRefs"></order>
                    <serveHistory ref="serveHistoryRefs"></serveHistory>
                    <IVR ref="ivrRefs"></IVR>
                    <custinfos ref="custinfosRefs" :mpappnum="mpappnum"></custinfos>
                    <csinfos ref="csinfosRefs"></csinfos>
                    <wxinfos ref="wxinfosRefs"></wxinfos>
                    <!-- <appinfos></appinfos> -->
                </div>
                <el-button
                    type="primary"
                    size="mini"
                    icon="el-icon-d-arrow-left"
                    :class="{ btnright: true, isrighticon: rightBtnClass }"
                    @click="handelmainleft"
                ></el-button>
            </div>
            <div class="businessSystem-box businessSystem-right" ref="businessSystem_right">
                <div v-show="!Card_3601flag" class="rightMain">
                    <!-- <cardComponent pageTitle="用户进线"> -->
                    <el-card class="box-card">
                        <div slot="header" class="clearfix">
                            <span>用户进线</span>
                        </div>
                        <div class="container">
                            <el-row>
                                <el-form
                                    ref="formData"
                                    :model="formData"
                                    :rules="rules"
                                    label-width="150px"
                                >
                                    <el-col :span="12">
                                        <div class="text_center width30">
                                            <el-form-item label="卡号:" prop="offlinetablecardnbr">
                                                <el-input
                                                    v-model.trim="formData.offlinetablecardnbr"
                                                    class="tsinput"
                                                    @change="trimCard"
                                                ></el-input>
                                            </el-form-item>
                                        </div>
                                        <div class="text_center width30">
                                            <el-form-item label="证件类型:">
                                                <el-select
                                                    v-model="formData.keytype"
                                                    clearable
                                                    class="tsinput"
                                                >
                                                    <el-option
                                                        v-for="item in papersType"
                                                        :label="item.label"
                                                        :key="item.code"
                                                        :value="item.code"
                                                    ></el-option>
                                                </el-select>
                                            </el-form-item>
                                        </div>
                                    </el-col>
                                    <el-col :span="12">
                                        <div class="text_center width30">
                                            <el-form-item label="证件号:" prop="offlinetablecustid">
                                                <el-input
                                                    v-model.trim="formData.offlinetablecustid"
                                                    class="tsinput"
                                                    @change="checkCard"
                                                ></el-input>
                                            </el-form-item>
                                        </div>
                                        <!-- <div class="text_center width30">
                                            <el-form-item label="授权原因:" prop="grantreason">
                                                <el-input
                                                    v-model.trim="formData.grantreason"
                                                    class="tsinput"
                                                ></el-input>
                                            </el-form-item>
                                        </div>-->
                                    </el-col>
                                </el-form>
                                <el-col :span="24">
                                    <div class="text_center margin_btm10">
                                        <el-button
                                            type="primary"
                                            size="small"
                                            @click.native="onSubmit"
                                            icon="el-icon-circle-check"
                                        >确定</el-button>
                                        <el-button
                                            size="small"
                                            icon="el-icon-refresh-right"
                                            @click.native="remove"
                                        >重置</el-button>
                                    </div>
                                </el-col>
                            </el-row>
                        </div>
                    </el-card>
                </div>

                <account-info
                    v-if="Card_3601flag"
                    :cardList="cardList"
                    @childHanderRadioCardnbr="childHanderRadioCardnbr"
                ></account-info>

                <business-operate ref="routerView"></business-operate>
            </div>
        </div>
    </div>
</template>

<script>
import moment from 'moment';
import { mapGetters, mapState } from 'vuex';
// import { PAPERS_TYPE } from 'utils/Contants'; // 页面一些常量
import { isEmptyObject, chargeObjectEqual } from '@/utils/Object';
import baseInfo from './baseInfo.vue'; // 客户基本信息
import accountTitle from './accountTitle.vue'; // 客户标签
import custinfos from './custinfos.vue';// 客户用卡情况
import order from './order.vue';// 工单
import serveHistory from './serveHistory.vue'; // 服务历史
import IVR from './IVR.vue'; // IVR轨迹
import accountInfo from './accountInfo.vue'; // 账户信息
import businessOperate from './businessOperate.vue'; // 账单
import csinfos from './csinfos.vue';// 催收信息
import wxinfos from './wxinfos.vue';// 非客服渠道服务历史
import '@/assets/css/businessSystem.css';
import { RegConfig } from '@/utils/RegConfig';
import { getDictFromBankNum, getDictSelectList, isEmpty } from '@/utils/Common';
import { getToken } from '@/utils/auth';
import cardComponent from '@/components/cardComponent/cardComponent.vue';
export default {
    // 交易号 3074按证件号查询持卡人卡号 可以查询多张卡来
    // 3002信用卡客户资料查询及更新
    // 3004按卡号查询卡资料信息 当前卡的详细信息
    name: 'businessSystem',
    data() {
        const validatorOfflinetablecustid = (rule, value, callback) => {
            if (value && this.formData.keytype == '01') {
                if (value.length == '18') {
                    console.log('证件号校验');
                    RegConfig.validateIdCard(rule, value, callback);
                } else {
                    callback(new Error('证件类型为18位身份证，长度错误！'));
                }
            } else if (value && this.formData.keytype == '02') {
                if (value.length == '15') {
                    RegConfig.validateIdCard(rule, value, callback);
                } else {
                    callback(new Error('证件类型为15位身份证，长度错误！'));
                }
            } else {
                callback();
            }
        };
        return {
            formData: {
                offlinetablecardnbr: '', // 卡号
                keytype: '01', // 证件类型
                offlinetablecustid: '', // 证件号
                // grantreason: '110', // 授权原因
            },
            papersType: [], // 证件类型下拉选
            buttonFlag: false, //防止坐席多次点击登录按钮
            defaultCardInfo: '', // 信用卡信息 可以用多卡 3004按卡号查询卡资料信息
            baseInfos: '', // 用户基本信息  3002信用卡客户资料查询及更新
            defaultParams: '', // 请求头参数
            // IDnumber:'',//记录 身份证件号
            // isEnter:false,// 是否登录
            cardList: [], // 3601按证件号查询持卡人卡号 多张
            flag: false,
            // CardnbrNumOption: '', // 给子集的卡号
            isformDefaultCardCARDNO: '',
            RTNIND_value: '', // 翻页标志
            last_card: '', // 最后一条卡号
            pageLoading: false,
            Card_3004flag: true, // 3004
            // Card_3601flag: false,//
            rightBtnClass: false, //
            accountType_option: [],//账户类别字典
            tableDataVal: '',
            checAllDataVal: '',
            stringLang: 30,//限制证件号的长度
            rules: {
                offlinetablecardnbr: [
                    { pattern: RegConfig.cardNo, message: '银行卡号应由13-21位数字组成', trigger: 'blur' },
                ],
                offlinetablecustid: [
                    { validator: validatorOfflinetablecustid, max: this.stringLang, trigger: 'blur', },
                ],
                // grantreason: [
                //     { required: true, message: '授权原因必填', trigger: 'blur' },
                //     { max: 30, message: '字符最大长度为30', trigger: 'blur' },
                // ],
                // offlinetablecustid:[
                //   {pattern: RegConfig.validateIdCard,message: '证件号错误!',trigger:'blur'}
                // ],
            },
            mpappnum: 0,//近一年分期办理次数，分付款交易明细可以查询统计

            NEXTDAY_3077: moment(new Date(new Date().getTime() - (1000 * 60 * 60 * 24 * 365))).format('YYYYMMDD'),//翻页交易日期
            NEXTMPNO_3077: '',//翻页分期付款序号
            RtnindFlag: '',//翻页标志
            startDate: moment(new Date(new Date().getTime() - (1000 * 60 * 60 * 24 * 365))).format('YYYYMMDD'), // 开始日期
            endDate: moment(new Date()).format('YYYYMMDD'), // 结束日期 默认为当前日期
            isChangeCardWatch: '',
        };
    },

    components: {
        baseInfo,
        'account-title': accountTitle,
        custinfos,
        order,
        serveHistory,
        IVR,
        accountInfo,
        businessOperate,
        cardComponent,
        csinfos,
        wxinfos,
        //appinfos,
    },
    // cardInfo_3004: state => state.common.cardInfo_3004
    computed: {
        ...mapGetters([
            'cardList_3601', //
            'isChangeCard', // 页面换卡状态
            'CardFromData', // 页面换卡内容
            'customerInfo_3002',
            'cardInfo_3004',
            'cardAccountInfo_3001',
            'currentSessionObj', // 电话件化
            'pinFlag', // 检查密码标志
            'CreditCardService_3014',
            'checkData', // 检查字段
            'checAllData',
            'globalVariable',//全局变量
        ]),
        Card_3601flag() {
            console.log('监听this.cardList_3601的数据是否删除了 ', this.cardList_3601);
            if (this.cardList_3601.length > 0 && (this.RTNIND_value === '0' || this.RTNIND_value === '') && this.Card_3004flag) {
                return true;
            } else {
                return false;
            }
        },
        // CrrountInfoFlag() {
        //     if (this.Card_3601flag && this.Card_3004flag) {
        //         return true;
        //     } else {
        //         return false;
        //     }
        // }
    },
    watch: {
        // // 监听 isChangeCard 是否被改变
        // isChangeCardWatch(newValue, oldValue) {
        //     // isChangeCard 等于 true 说明开始修改卡号了
        //     console.log('换卡标识符', 'newValue', newValue, 'oldValue', oldValue);
        //     if (this.isChangeCard) {
        //         // 修改formData 数据 this.CardFromData;
        //         this.formData = JSON.parse(JSON.stringify(this.CardFromData));
        //         this.getUserInfo();
        //     }
        // },
        // 监听 isChangeCard 是否被改变
        isChangeCard(newValue, oldValue) {
            // isChangeCard 等于 true 说明开始修改卡号了
            if (newValue) {
                // 修改formData 数据 this.CardFromData;
                this.formData = JSON.parse(JSON.stringify(this.CardFromData));
                this.getUserInfo();
            }
        },
        // 软电话 进线 查询卡信息 
        async currentSessionObj(newValue, oldValue) {
            await this.remove();
            console.log(oldValue, '缓存数据清除22222222');
            console.log(newValue, 'currentSessionObj,newValue___22222222222222');
            // 如果当前的 currentSessionObj 为空
            if (isEmptyObject(newValue)) {
                return false
            } else if (newValue.ani !== '') {
                console.log('缓存数据清除22222222——2222222222');
                await this.closeNewCustPage();
                // //查询来电号码归属地
                this.getTelNumCitys(newValue);
                if (top.softphone.direction === 'in') {
                    if (newValue.ivrData.data.CARD) {
                        // 卡登录
                        this.formData.offlinetablecardnbr = newValue.ivrData.data.CARD;
                        // this.formData.grantreason = newValue.ivrData.data.CARD;
                        await this.onSubmit();
                    } else if (newValue.ivrData.data.IDNO) {
                        // 证件登录
                        this.formData.offlinetablecustid = newValue.ivrData.data.IDNO;
                        this.formData.keytype = newValue.ivrData.data.IDTYPE;
                        await this.onSubmit();
                    }
                }
                // this.$store.commit('menu/SET_MULTI_USER',true)

            }
        },
    },
    mounted() {
        this.defaultParams = this.$store.getters.defaultParams;
        this.defaultCardInfo = this.$store.getters.cardInfo_3004;
        // console.log('this.$store.getters.cardInfo_3004.CARDNO', this.$store.getters.cardInfo_3004.CARDNO);
        this.formData.offlinetablecardnbr = this.$store.getters.cardInfo_3004.CARDNO || '';
        if (!isEmptyObject(this.customerInfo_3002)) {
            this.baseInfos = this.customerInfo_3002;
        }
        this.cardList = this.cardList_3601;
        //  软电话 进线 会强制跳转路径 到这个页面
        this.getMlidPhone();
        // 进来就开始查字典
        this.getDictValue();
        // 显示 nav-head 组件 这个方法不要删除
        this.$store.commit('menu/UPDATA_SHOW_NAV_HEAD', true);
    },
    methods: {
        // 关闭客户视图，跳转到坐席首页
        async closeNewCustPage() {
            // 关闭客户视图 不清除  currentSessionObj
            await this.$store.dispatch('common/delStateAllagNew').then(() => {
                console.log('AG______交易数据已清除');
            });
            console.log('AG______交易数据已清除11111');
            this.$store.commit('tagsView/DEL_NUM_CACHED_VIEWS_ITEM');
            this.$store.commit('tagsView/DEL_NUM_VISITED_VIEWS_ITEM');
            // menu 里的state 删除
            this.$store.commit('menu/DELECT_ALL_STATE_INITIAL');
            // this.$store.dispatch('tagsView/delAllVisitedViewsItem');
            // 控制 tagsview 是否显示 问题 false 显示 true不显示
            this.$store.commit('menu/UPDATE_ACTIVE_MENU', true);
            // 显示 nav-head 组件
            this.$store.commit('menu/UPDATA_SHOW_NAV_HEAD', true);
            this.$store.commit('common/UPDATE_RISKLEVEL', 0);

            // 清除当前页面原有的数据 等待下次数据进入
            this.cardList = [];
            this.baseInfos = {};
            this.defaultCardInfo = {};
            this.Card_3004flag = true;


        },
        //查询来电号码归属地
        async getTelNumCitys(newValue) {
            let params = {
                mobile: newValue.ani,
            };
            await this.$post.telNumInfo.getTelNumCity(params).then(async (res) => {
                newValue.area = res.data.msg;
                await this.$store.commit('common/UPDATA_CURRENT_SESSION_OBJ', newValue);
            });
        },
        async getDictValue() {
            this.papersType = await getDictSelectList('IDTYPE', this);
            // CATE
            this.accountType_option = await getDictSelectList('CATE', this);

        },
        async onSubmit() {
            if (getToken() && JSON.parse(getToken()).roleType.indexOf('5') === -1) {
                this.$alert('此坐席为非离线坐席!', '提示', {
                    customClass: 'warning', type: 'warning',
                });
                return;
            }

            if (!this.formData.offlinetablecardnbr && !this.formData.offlinetablecustid) {
                this.$alert('请输入卡号或证件号!', '提示', {
                    customClass: 'warning', type: 'warning',
                }); return;
            }

            if (this.formData.offlinetablecustid && !this.formData.keytype) {
                this.$alert('请选择证件类型！', '提示', {
                    customClass: 'warning', type: 'warning',
                }); return;
            }
            let cardno = this.formData.offlinetablecardnbr;
            let custid = this.formData.offlinetablecustid;
            if (cardno !== '' && custid.trim() !== '') {
                this.$alert('卡号和证件号码只能输入一个!', '提示', {
                    customClass: 'warning', type: 'warning',
                }); return;
            }
            await this.$refs.formData.validate((valid) => {
                if (valid) {
                    // 登录之前 添加个 清除缓存的动作 用于 离线坐席 突然有电话进线
                    if (this.buttonFlag) return;
                    this.buttonFlag = true;
                    this.pageLoading = true;
                    this.getUserInfo();
                }
            });
        },
        async getUserInfo() {
            // 判断卡号是否有值
            if (this.formData.offlinetablecardnbr) { // 卡号
                await this.getIdNumber();
            } else if (this.formData.offlinetablecustid) { // 证件号
                this.Card_3004flag = false;
                await this.getBaseInfo();
            }

            this.buttonFlag = false;
        },

        // 软电话 进线
        async getMlidPhone() {
            console.log('缓存数据清除111');
            console.log('session,监听软电话进线路劲11111111111');
            if (!isEmpty(this.currentSessionObj.ani)) {
                this.remove();
                await this.closeNewCustPage()
            } else {
                return false;
            }
            // 3601 没有值 且 软电话 有值 
            if (this.cardList_3601.length == 0 && (!isEmptyObject(this.currentSessionObj))) {
                this.getTelNumCitys(this.currentSessionObj);
                await this.getIsVip();
                if (top.softphone.direction === 'in') {
                    if (this.currentSessionObj.ivrData.data.CARD) {
                        // 卡登录
                        this.formData.offlinetablecardnbr = this.currentSessionObj.ivrData.data.CARD;
                        // this.formData.grantreason = this.currentSessionObj.ivrData.data.CARD;

                        await this.getUserInfo();
                    } else if (this.currentSessionObj.ivrData.data.IDNO) {
                        // 证件登录
                        this.formData.offlinetablecustid = this.currentSessionObj.ivrData.data.IDNO;
                        this.formData.keytype = this.currentSessionObj.ivrData.data.IDTYPE;
                        await this.getUserInfo();
                    }
                }
            }
        },
        // } else {
        //   return false;
        // }
        // });
        // 设置当前卡 为默认卡
        async childHanderRadioCardnbr(acrdnbrNum) {
            console.log('acrdnbrNum', '换卡操作', acrdnbrNum);
            console.log('输出卡号', this.formData.offlinetablecardnbr);
            this.flag = true;
            // 获取上个卡片的卡号  cardInfo_3004.CARDNO 和卡片状态 cardInfo_3004
            console.log(`第一次输出的是上个默认卡${this.cardInfo_3004.CARDNO}和卡片的证件类型${this.cardInfo_3004.CARDSTAT}`);
            await this.updateChec(this.cardInfo_3004, false);
            await this.getIdNumber(acrdnbrNum);
            //切换 默认卡 从新请求 校验规则
            // await this.getValidruleDate();
            // 事件加载 需要时间
        },

        //  软电话进线 判断客户是否是VIP 
        async getIsVip() {
            const params = {
                phone: '', // 13627844590
            };
            let isVIP = '';
            if (top.softphone.direction === 'out') { // 外呼
                params.phone = this.currentSessionObj.ani;
            } else if (top.softphone.direction === 'in') { // 呼入
                params.phone = this.currentSessionObj.dnis;
            }

            await this.$post.blackAndWhiteMangage.updateIsVIP(params).then((res) => {
                // console.log(res,'res_1111111111111111111111111');
                if (res.data.success) {
                    if (res.data.content) {
                        isVIP = res.data.content.blackType;
                    }
                    // vip数据没有拿到报错 先注释
                    // isVIP = res.data.content.blackType;
                }
            });
            if (isVIP === '4') {
                this.$store.commit('menu/UPDATA_USER_IS_VIP', true);
            } else {
                this.$store.commit('menu/UPDATA_USER_IS_VIP', false);
            }
        },
        // 触发点击时 发送 事件
        // 请求用户基本信息 3002
        async getBaseInfo() {
            if (isEmptyObject(this.checAllData)) {
                await this.getValidruleDate();
            }
            const defaultParamInfo = JSON.parse(JSON.stringify(this.defaultParams));
            console.log(' this.formData.offlinetablecardnbr ____3002里的', this.formData.offlinetablecardnbr);
            defaultParamInfo.body.appHead.tranCode = '3002';// 修改交易号
            defaultParamInfo.body.appBody = { // 业务报文
                CARDNO: this.formData.offlinetablecardnbr, // 卡号
                CARDNBR: this.formData.offlinetablecardnbr,
                OPTION: 1, // 1:查询 2：修改 3：按位图修改 4：新增（仅北京银行）按手机号码方式查询时，只能查询不能修改，也不能按位图修改
                INQOPT: this.formData.offlinetablecardnbr ? '1' : '2', // 查询方式 // 1-按卡号查询 2-按证件号查询 3-按手机号码查询             //业务报文
                CUSTID: this.formData.offlinetablecustid,
                KEYTYPE: this.formData.keytype, // 证件类型
                PIN: '',
                finavaiYn: '0',
                CARDNBR3074: '',
                OPTION3054: '1',
                QUERY: '0',
                PINFLAG: '0', // 0-不检查密码 1-检查卡片级查询密码 2-检查取款密码 3-检查客户级查询密码
            };
            await this.$post.common.transPort(defaultParamInfo).then((res) => {
                if (res.status === 200) { // 请求成功
                    // // console.log(res);
                    const baseData = JSON.parse(res.data.jsonRes);
                    console.log(baseData, '3002_户基本信息');
                    if (baseData.sysHead.rspCd == '000000') { // 交易成功
                        // const baseDataList = [...baseData.body.appBody]
                        this.baseInfos = baseData.body.appBody;
                        //  // console.log( this.baseInfos,'');
                        // 判断卡号是否有值 如果没有卡号
                        if (!this.formData.offlinetablecardnbr) {
                            // console.log(this.formData.offlinetablecardnbr, 'this.formData.offlinetablecardnbr -> 3074');
                            this.getBusinessSystem();
                        }
                        // 获取 预留手机号
                        this.getHomephone(baseData.body.appBody);
                        // 获取查询密码校验
                        this.getCheckpwd();
                        // Object.assign(this.cardInfo,cardData.body.appBody.dataList);
                        // sessionStorage.setItem("baseInfo_3002", JSON.stringify(this.baseInfo));
                        // 更新vuex里的用户基本信息
                        this.$store.commit('common/UPDATE_CUS_INFO', baseData.body.appBody);
                    } else {
                        const ErrorMessage = `错误码：${baseData.sysHead.rspCd} ` + `错误信息：${baseData.sysHead.rspMsg}`;
                        this.$alert(ErrorMessage, baseData.sysHead.busiName, {
                            customClass: 'error', type: 'error',
                        });
                        this.pageLoading = false;
                    }
                }
            });
        },
        // 获取 预留手机号
        getHomephone(BaseInfo3002) {
            const checAllDataItem = JSON.parse(JSON.stringify(this.checAllData));
            let homephone6 = BaseInfo3002.HOMEPHONE.trim();
            let mbphone11 = BaseInfo3002.MOBILEPHONE.trim();
            if (homephone6 != '') {
                homephone6 = homephone6.substring(homephone6.length - 6, homephone6.length);
            }
            if (mbphone11 != '') {
                mbphone11 = mbphone11.substring(mbphone11.length - 11, mbphone11.length);
            }
            let reservflag = true;
            if (!(this.currentSessionObj.ani === '' || this.currentSessionObj.ani === undefined)) {
                let anis = this.currentSessionObj.ani.trim();
                if (anis.substring(anis.length - 6, anis.length) != homephone6 && anis.substring(anis.length - 11, anis.length) != mbphone11) {
                    reservflag = false;
                } else {
                    reservflag = true;
                }
            }
            checAllDataItem.check_reserve_mobile.falg = reservflag;
            // console.log('reservflag', reservflag);
            // console.log(`这里是修改了 预留手机号状态：名称为：${checAllDataItem.check_reserve_mobile.label}值为：${checAllDataItem.check_reserve_mobile.falg}：大对象为`, checAllDataItem);
            this.$store.commit('common/SAVE_CHECK_DATA', checAllDataItem);

        },
        // 获取查询密码校验
        getCheckpwd() {
            const checAllDataItem = JSON.parse(JSON.stringify(this.checAllData));
            let pwdflag = true;
            if (!(this.currentSessionObj.ivrData === '' || this.currentSessionObj.ivrData === undefined)) {
                pwdflag = this.currentSessionObj.ivrData.data.AUTH === '1' ? true : false;
            }
            checAllDataItem.check_pwd.falg = pwdflag;
            // console.log('pwdflag', pwdflag);
            // console.log(`这里是修改了 查询密码校验：名称为：${checAllDataItem.check_pwd.label}值为：${checAllDataItem.check_pwd.falg}：大对象为：`, checAllDataItem);
            this.$store.commit('common/SAVE_CHECK_DATA', checAllDataItem);
        },
        // 第一次进来 跑3003 交易 3003信用卡客户资料地址查询及更新
        async getAddress(CardNum) {
            const appBody = {
                CARDNBR: CardNum,
                INQOPT: 1,
                OPTION: 1,
                PINFLAG: this.pinFlag, // 0-不检查密码 1-检查卡片级查询密码 2-检查取款密码 3-检查客户级查询密码
            };
            const params = JSON.parse(JSON.stringify(this.defaultParams));
            params.body.appHead.tranCode = '3003';
            params.body.appBody = appBody;
            await this.$post.common.transPort(params).then((res) => {
                if (res.status === 200) { // 请求成功
                    const results = JSON.parse(res.data.jsonRes);
                    if (results.sysHead.rspCd === '000000') { // 交易成功
                        const data = results.body.appBody;
                        console.log(data, 'result -- 3003');
                        // 更新vuex里的用户基本信息
                        this.$store.commit('common/UPDATE_CUS_ADDR_INFO', data);
                    } else { // 交易失败
                        this.$store.commit('common/UPDATE_CUS_ADDR_INFO', {});
                        this.$message.error(`${results.sysHead.rspMsg}3003`);
                    }
                } else { // 请求失败
                    this.$alert('请求失败!', '提示', {
                        customClass: 'error', type: 'error',
                    });
                }
            });
        },

        // 3004 按卡号查询卡资料信息
        async getIdNumber(acrdnbrNum) {
            // 获取规则列表 
            if (isEmptyObject(this.checAllData)) {
                await this.getValidruleDate();
            }
            const defaultParamInfo = JSON.parse(JSON.stringify(this.defaultParams));
            defaultParamInfo.body.appHead.tranCode = '3004';// 修改交易号
            defaultParamInfo.body.appBody = {
                CARDNO: acrdnbrNum || this.formData.offlinetablecardnbr,
                CARDNBR: acrdnbrNum || this.formData.offlinetablecardnbr,
                PINFLAG: '0',
            },
                // // console.log(defaultParamInfo);
                await this.$post.common.transPort(defaultParamInfo).then(async (res) => {
                    const IDNumData = JSON.parse(res.data.jsonRes);
                    if (res.status === 200) { // 请求成功
                        console.log(IDNumData, '3004_卡资料信息');
                        if (IDNumData.sysHead.rspCd == '000000') { // 交易成功
                            this.formData.offlinetablecustid = IDNumData.body.appBody.CUSTID;
                            this.formData.keytype = IDNumData.body.appBody.KEYTYPE;
                            if (this.cardList.length == 0 || this.isChangeCard) {
                                this.getBusinessSystem();
                            }
                            // let checAllData = this.checAllData
                            // 判断卡状态
                            // const reslut_3004CARDSTAT =  reslut_3004.CARDSTAT.trim() || '空'
                            // if(checAllData[reslut_3004CARDSTAT]) checAllData[reslut_3004CARDSTAT].falg = true
                            // 判断卡状态
                            // const reslut_3004CARDSTAT =  reslut_3004.CARDSTAT.trim() || '空'
                            // if(checAllData[reslut_3004CARDSTAT]) checAllData[reslut_3004CARDSTAT].falg = true

                            // 判断是否有新卡 checAllData
                            if ((`${IDNumData.body.appBody.NEWCARD}`).trim() === '') {
                                console.log(IDNumData.body.appBody.NEWCARD, '是否有新卡____ 没有');
                                this.defaultCardInfo = IDNumData.body.appBody;
                                this.$store.commit('common/UPDATE_CARD_INFO_ONE', IDNumData.body.appBody);

                                // 修改状态 统一修改验证开关的卡状态
                                console.log(`第二次次输出的是当前默认卡${IDNumData.body.appBody.CARDNO}和卡片的证件类型${IDNumData.body.appBody.CARDSTAT}`);
                                await this.updateChec(IDNumData.body.appBody, true);
                                // if(this.defaultCardInfo.CARDSTAT.trim() === '') {
                                //     const checkData = JSON.parse(JSON.stringify(this.checkData))

                                //     checkData.cardStatusCheckFlag = true
                                //     this.$store.commit('common/UPDATE_CHECK_FLAG', checkData);
                                // }
                                // 修改请求报文里默认卡号
                                // this.$store.commit('UPDATE_DEFAULT_CARDNO_PARAMS', IDNumData.body.appBody.CARDNO);
                                // this.CardnbrNumOption = IDNumData.body.appBody.CARDNO;

                                // 触发点击时 发送 事件
                                if (this.flag) {
                                    this.$refs.routerView.getIndexValue();
                                }

                                this.flag = false;
                                // 根据卡号 查询用户地址信息
                                this.getAddress(IDNumData.body.appBody.CARDNO);
                                //  3002
                                // 证件号进线 Card_3004flag 为false
                                if (this.Card_3004flag) {
                                    this.getBaseInfo();
                                }

                                this.Card_3004flag = true;

                                // 3014
                                this.getCreditCardInfo3014();
                                // 3001
                                this.getCardAccount3001();
                                this.getCardBill3005();
                                this.getCardHistory3054();
                                this.mpappnum = 0;
                                this.get3077();
                                this.get4017();
                                //修改 全局变量里的数据
                                let globalVariables = Object.assign({}, this.globalVariable);
                                globalVariables.isCoilIn = true;
                                const intervalTime = setTimeout(() => {
                                    this.$store.commit('menu/UPDATE_GLOBAL_VARIABLE', globalVariables);
                                    clearTimeout(intervalTime);
                                }, 1000)
                                // 在这里调用侧边 组件加载的方法
                                // console.log('110_________________110', this.$refs.ivrRefs);
                                // 获取 IVR轨迹 数据
                                this.$refs.ivrRefs.getIVRlist();
                                //  // 服务历史
                                this.$refs.serveHistoryRefs.getserveHistory()
                                // 获取客户标签数据
                                this.$refs.custinfosRefs.getInitData()
                                //  // 获取工单表格数据
                                this.$refs.csinfosRefs.getInitData()
                                // 非客服渠道服务历史
                                this.$refs.wxinfosRefs.init()
                                // 获取工单表格数据 

                                // 工单数据是通过证件号查询 所以 换卡 不需要更新
                                this.$refs.orderRefs.getInitData('1');
                            } else {
                                // 有新卡时 先修改 formData 里的数据
                                this.formData.offlinetablecardnbr = (`${IDNumData.body.appBody.NEWCARD}`).trim();
                                // console.log(IDNumData.body.appBody.NEWCARD, '新卡号，再次查询3004');
                                this.getIdNumber((`${IDNumData.body.appBody.NEWCARD}`).trim());
                            }
                        } else {
                            const ErrorMessage = `错误码：${IDNumData.sysHead.rspCd} ` + `错误信息：${IDNumData.sysHead.rspMsg}`;
                            this.$alert(ErrorMessage, '信息查询', {
                                customClass: 'error', type: 'error',
                            });
                            this.pageLoading = false;
                        }
                    } else {
                        const ErrorMessage = `错误码：${IDNumData.sysHead.rspCd} ` + `错误信息：${IDNumData.sysHead.rspMsg}`;
                        this.$alert(ErrorMessage, '信息查询', {
                            customClass: 'error', type: 'error',
                        });
                        this.pageLoading = false;
                    }
                });
        },
        // 获取规则列表在mounted钩子函数获取并将数据保存到vuex
        // 所有的校验规则 是从字典里 取的 取完存起来
        // 在点击菜单时 跟
        async getValidruleDate() {
            // 校验规则
            const tableData = await getDictSelectList('VALIDRULE', this);
            // 将安全级别单独存到data中，方便判断获取到的id是否存在
            this.tableSAFETY = await getDictFromBankNum('VALIDRULE_SAFETY', this);
            // 校验帐户类型
            const tableACCOUNT = await getDictFromBankNum(
                'VALIDRULE_ACCOUNT_TYPE',
                this,
            );
            // 卡状态校验规则
            const tableSTATUS = await getDictFromBankNum('VALIDRULE_CARD_STATUS', this);

            this.tableDataVal = [
                { type: '禁止账户类别', val: tableACCOUNT },
                { type: '安全级别', val: this.tableSAFETY },
                { type: '禁止卡状态', val: tableSTATUS },
                { type: '其他验证', val: tableData },
            ];
            // 保存
            this.checAllDataVal = {};
            this.$store.commit('common/SAVE_LOAD_VALIDRULE', this.tableDataVal);
            // 处理成检验需要的开关文件，默认全部 falg=false 不验证
            this.tableDataVal.forEach((item) => {
                // console.log('item.val___________2', item.val);
                item.val.forEach((codeData) => {
                    // 在这里做验证开关 falg=true 开始验证   初始状态 校验结果都是可以通过 给 false 不校验
                    this.checAllDataVal[codeData.code] = { falg: false, label: codeData.label, dictValue: codeData.dictValue };
                });
            });
            const aaa = JSON.parse(JSON.stringify(this.checAllDataVal))
            // console.log('checAllDataValss ————————第一次拼装成的校验规则', 'aaa', aaa, ' this.checAllDataVal', this.checAllDataVal);
            // 第一次存储 全是false  状态正确
            await this.$store.commit('common/SAVE_CHECK_DATA', this.checAllDataVal);
        },

        // 判断一下  checAllDataVal   和   checAllData 里的俩值是否 一致
        // 肯定一致

        // 修改验证开关 每次 更新卡号 后 卡片状态不正确 更新卡片状态 
        async updateChec(reslut_3004, tage) {
            const checAllDataItem = JSON.parse(JSON.stringify(this.checAllData))
            // "CATEGORY_10": {
            //     "falg": false,
            //         "label": "个人卡账户",
            //             "dictValue": "VALIDRULE_ACCOUNT_TYPE"
            // },
            // "none": {
            //     "falg": false,
            //         "label": "不验证",
            //             "dictValue": "VALIDRULE_SAFETY"
            // },
            // "H": {
            //     "falg": false,
            //         "label": "账户止付",
            //             "dictValue": "VALIDRULE_CARD_STATUS"
            // },
            console.log('菜单校验规则_______123___123', '没改之前的:', checAllDataItem);
            // 判断卡状态 是个字符串
            // console.log('打印3004的卡片状态', reslut_3004.CARDSTAT);
            // console.log('打印需要校验的规则', checAllDataItem);
            // console.log('checAllDataItem[reslut_3004CARDSTAT]', checAllDataItem[reslut_3004CARDSTAT]);
            const reslut_3004CARDSTAT = reslut_3004.CARDSTAT.trim() || '空';

            // 禁止卡状态是否正常
            if (checAllDataItem[reslut_3004CARDSTAT]) { checAllDataItem[reslut_3004CARDSTAT].falg = tage; }
            // if (checAllDataItem.check_card_status) {
            //     if (reslut_3004CARDSTAT !== '空') checAllDataItem.check_card_status.falg = true;
            // }

            //切换默认卡时 需要把上一个卡的状态改过来 （checAllData里 falg 为true的改为false）


            // 判断卡是否为副卡，禁止副卡
            // const reslut_3004MAFLAG = (`${reslut_3004.MAFLAG}`).trim();
            // if (checAllDataItem.check_secondary) {
            //     if (reslut_3004MAFLAG !== 1) checAllDataItem.check_secondary.falg = true;
            // }
            // 验证账户类型, 先获取到当前账户类别
            console.log('reslut_3004.CATEGORY_当前的账户类型', reslut_3004.CATEGORY);
            const reslut_3004CATEGORY = (`CATEGORY_${reslut_3004.CATEGORY}`).trim();
            // console.log('处理校验,判断是否进行校验', reslut_3004.CATEGORY);
            if (checAllDataItem[reslut_3004CATEGORY]) { checAllDataItem[reslut_3004CATEGORY].falg = tage; }

            // console.log('checAllData_____111111100001010100___修改后的校验规则', checAllDataItem);
            // 修改验证开关 结束后再 保存一下 checAllDataItem
            console.log(`这里是修改了 ：名称为：${checAllDataItem[reslut_3004CATEGORY].label}值为：${checAllDataItem[reslut_3004CATEGORY].falg}`);
            console.log(`这里是修改了 ：名称为：${checAllDataItem[reslut_3004CARDSTAT].label}值为：${checAllDataItem[reslut_3004CARDSTAT].falg}：大对象为`, checAllDataItem);
            this.$store.commit('common/SAVE_CHECK_DATA', checAllDataItem);
            console.log('菜单校验规则已更新----------------', checAllDataItem);
        },

        // 请求信用卡信息 3074 改 3601交易
        async getBusinessSystem() {
            const defaultParamInfo = JSON.parse(JSON.stringify(this.defaultParams));
            defaultParamInfo.body.appHead.tranCode = '3601';// 修改交易号
            defaultParamInfo.body.appBody = { // 业务报文
                // OPT: '2', // 查询方式 1-卡号查询  2-证件号查询
                KEYTYPE: this.formData.keytype ? this.formData.keytype : '01', // 证件类型
                CUSTID: this.formData.offlinetablecustid, // 证件号码
                PINFLAG: this.pinFlag, // 是否检查密码标志
                PIN: '', // 密码
                RTNIND: this.RTNIND_value, //this.RTNIND_value RTN-IND 翻页标志
                CARDNBR: this.last_card ? this.last_card : '', // 翻页卡号
                INSFLAG: '1',
            };
            await this.$post.common.transPort(defaultParamInfo).then((res) => {
                if (res.status === 200) { // 请求成功
                    this.isEnter = true;
                    // // console.log(res);
                    const cardData = JSON.parse(res.data.jsonRes);
                    console.log(cardData, '3601_信用卡信息');
                    if (cardData.sysHead.rspCd == '000000') { // 交易成功
                        // 有数据 换卡 先清空卡列表
                        if (this.isChangeCard) {
                            this.cardList = [];
                        }
                        this.cardList.push(...cardData.body.appBody.dataList);
                        this.RTNIND_value = cardData.body.appBody.RTNIND;
                        if (this.RTNIND_value === '1') {
                            this.last_card = (`${cardData.body.appBody.dataList[4].CARDNBR}`).trim();
                            this.getBusinessSystem();
                        } else {
                            this.RTNIND_value = '';
                            this.last_card = '';
                            // 更新vuex里的卡信息
                            let AccountInfos = [];
                            let cardTypeList = [];
                            this.cardList.forEach((item) => {
                                // 遍历 字典里的账户选项 和账户值
                                this.accountType_option.some((indexval) => {
                                    // console.log('indexval.CARDNBR', indexval.CARDNBR);
                                    // 如果账户里有这个值 
                                    if (indexval.code === item.CATEGORY + '') {
                                        // 新加的 AccountInfos里是否有这个
                                        if (AccountInfos.length == 0 || !(AccountInfos.some((i) => i.code === indexval.code))) {
                                            indexval.CARDNBR = item.CARDNBR.trim();
                                            AccountInfos.push(indexval);
                                        } else {
                                            return true
                                        }
                                    }
                                })
                            });
                            //统计 当前类型的卡种 有多少个 
                            this.getCardTypeNumFun(this.cardList, AccountInfos);
                            this.$store.commit('common/UPDATE_Accountion_TYPE_INFO', AccountInfos);
                            this.$store.commit('common/UPDATE_CARD_LIST', this.cardList);
                            this.pageLoading = false;
                            // 判断主卡
                            // 如果默认卡3004没有数据 拿第一条主卡为卡号 去请求数据
                            // 如果是换卡 isChangeCard = true
                            if (isEmptyObject(this.cardInfo_3004) || this.isChangeCard) {
                                let isMaflag = '';
                                for (let index = 0; index < this.cardList.length; index++) {
                                    const element = this.cardList[index];
                                    isMaflag = (`${element.MAFLAG}`).trim();
                                    if (isMaflag === '1') {
                                        // console.log(element.CARDNBR,'element.CARDNBR');
                                        this.formData.offlinetablecardnbr = element.CARDNBR;
                                        // this.isformDefaultCardCARDNO = element.CARDNBR;
                                        // 这时开始查 默认卡信息
                                        this.getIdNumber(this.formData.offlinetablecardnbr);
                                        break;
                                    }
                                }
                                console.log('110');
                                // 循环体结束后 没有找到主卡 拿第一张副卡 进线
                                if (isMaflag !== '1') {
                                    const cardListOne = this.cardList[0].CARDNBR || '';
                                    this.getIdNumber(cardListOne);
                                }

                            }
                        }
                    } else {
                        // rspMsg
                        const ErrorMessage = `错误码：${cardData.sysHead.rspCd} ` + `错误信息：${cardData.sysHead.rspMsg}`;
                        this.$alert(ErrorMessage, cardData.sysHead.busiName, {
                            customClass: 'error', type: 'error',
                        });
                        this.pageLoading = false;
                    }
                    // this.isShowUserinfo = true;
                    // 最后 修改 isChangeCard的状态
                    this.$store.commit('menu/UPDATA_CHANGE_CARD_FLAG', false);
                }
            });
        },
        //统计 当前类型的卡种 有多少个 
        getCardTypeNumFun(cardList, AccountInfos) {
            for (let i = 0; i < AccountInfos.length; i++) {
                let cardTypeNum = cardList.filter((item) => item.CATEGORY + '' === AccountInfos[i].code);
                AccountInfos[i].typeNum = cardTypeNum.length;
            }
        },
        // 3001信用卡账户查询 CardnbrNumOption 字段走3004 会更新
        async getCardAccount3001() {
            const defaultParamInfos = JSON.parse(JSON.stringify(this.defaultParams));
            defaultParamInfos.body.appHead.tranCode = '3001';// 修改交易号
            defaultParamInfos.body.appBody = {
                PINFLAG: this.pinFlag,
                PIN: '',
                CARDNO: this.defaultCardInfo.CARDNO || this.formData.offlinetablecardnbr,// 卡号
            }
            await this.$post.common.transPort(defaultParamInfos).then((res) => {
                if (res.status === 200) { // 请求成功
                    const cardlossofs = JSON.parse(res.data.jsonRes);
                    console.log(cardlossofs, '3001信用卡账户查询');
                    if (cardlossofs.sysHead.rspCd == '000000') { // 交易成功
                        // 更新 vuex 缓存 卡账户信息
                        // this.cardAccountInfos_3001 =  cardlossofs.body.appBody;
                        const data = cardlossofs.body.appBody;
                        this.$store.commit('common/UPDATE_CARD_ACCOUNT_INFO', data);
                        // if (data.CARDSTAT.trim() === '') {
                        // const checkData = JSON.parse(JSON.stringify(this.checkData))
                        // checkData.accountStatusCheckFlag = true
                        // this.$store.commit('common/UPDATE_CHECK_FLAG', checkData)
                        // 顺带修改一下校验开关的里面的数据 验证账户状态
                        // this.checAllData.check_acount_status.falg = true;
                        // console.log(this.checAllData);
                        // }
                        // this.remove();
                    } else {
                        this.$store.commit('common/UPDATE_CARD_ACCOUNT_INFO', {});
                        // let ErrorMessage = '错误码：'+cardlossofs.sysHead.rspCd+' '+'错误信息：'+cardlossofs.sysHead.rspMsg;
                        // this.$alert(ErrorMessage, cardlossofs.sysHead.busiName, {
                        //     customClass: 'error'
                        // })
                    }
                } else {
                    this.$message.error(cardlossofs.sysHead.rspMsg);
                }
            });
        },
        // 3014信用卡服务方式综合查询 查字典 billsnd
        async getCreditCardInfo3014() {
            const defaultParamInfo = JSON.parse(JSON.stringify(this.defaultParams));
            defaultParamInfo.body.appHead.tranCode = '3014';// 修改交易号
            defaultParamInfo.body.appBody = {
                PINFLAG: '0',
                PIN: '',
                CARDNBR: this.defaultCardInfo.CARDNO || this.formData.offlinetablecardnbr,// 卡号
            };
            await this.$post.common.transPort(defaultParamInfo).then((res) => {
                // console.log(res);
                if (res.status === 200) { // 请求成功
                    const CreditCard = JSON.parse(res.data.jsonRes);
                    console.log(CreditCard, '3014信用卡服务');
                    if (CreditCard.sysHead.rspCd == '000000') { // 交易成功
                        // this.creditCard_3014= CreditCard.body.appBody;
                        // this.isShowSuccess=true;
                        // 更新vuex 数据
                        this.$store.commit('common/UPDATE_CREDIT_CARD_SERVICE', CreditCard.body.appBody);
                    } else {
                        this.$store.commit('common/UPDATE_CREDIT_CARD_SERVICE', {});
                        // let ErrorMessage = '错误码：'+CreditCard.sysHead.rspCd+' '+'错误信息：'+CreditCard.sysHead.rspMsg;
                        // this.$alert(ErrorMessage, CreditCard.sysHead.busiName, {
                        //     customClass: 'error'
                        // })
                    }
                }
            });
        },
        // 3005信用卡账单头查询
        async getCardBill3005() {
            const defaultParamInfos = JSON.parse(JSON.stringify(this.defaultParams));
            defaultParamInfos.body.appHead.tranCode = '3005';// 修改交易号
            defaultParamInfos.body.appBody = {
                PINFLAG: '0',
                PIN: '',
                CARDNO: this.cardInfo_3004.CARDNO,// 卡号
                CARDNBR: this.cardInfo_3004.CARDNO,// 卡号
                TRANYM: '0000',
                OPTION: 'L',
            };
            await this.$post.common.transPort(defaultParamInfos).then((res) => {
                // // console.log(res);
                if (res.status === 200) { // 请求成功
                    const cardlossofs = JSON.parse(res.data.jsonRes);
                    console.log(cardlossofs, '3005信用卡账单头查询');
                    if (cardlossofs.sysHead.rspCd == '000000') { // 交易成功
                        // 更新 vuex 缓存 卡账户信息
                        console.log(cardlossofs.body.appBody, '3005');
                        this.$store.commit('common/UPDATE_CARD_BILL', cardlossofs.body.appBody);
                    } else {
                        console.log('外面的');
                        this.$store.commit('common/UPDATE_CARD_BILL', {});
                        // let ErrorMessage = '错误码：'+cardlossofs.sysHead.rspCd+' '+'错误信息：'+cardlossofs.sysHead.rspMsg;
                        // this.$alert(ErrorMessage, cardlossofs.sysHead.busiName, {
                        //     customClass: 'error'
                        // })
                    }
                }
            });
        },
        // 3054卡片信用历史查询（ACRED）
        async getCardHistory3054() {
            const defaultParamInfos = JSON.parse(JSON.stringify(this.defaultParams));
            defaultParamInfos.body.appHead.tranCode = '3054';// 修改交易号
            defaultParamInfos.body.appBody = {
                PINFLAG: '0',
                PIN: '',
                CARDNO: this.cardInfo_3004.CARDNO,// 卡号
                CARDNBR: this.cardInfo_3004.CARDNO,// 卡号
                OPTION: 'L',// 第一币种
                QUERY: '0', // 19-24月的信用历史
            };
            await this.$post.common.transPort(defaultParamInfos).then((res) => {
                // console.log(res);
                if (res.status === 200) { // 请求成功
                    const cardlossofs = JSON.parse(res.data.jsonRes);
                    console.log(cardlossofs, '3054卡片信用历史');
                    if (cardlossofs.sysHead.rspCd == '000000') { // 交易成功 CUPAYM24
                        // this.isCard3054= cardlossofs.body.appBody
                        // this.CUPAYM24_Value = cardlossofs.body.appBody.CUPAYM24;
                        // 更新vuex 数据
                        this.$store.commit('common/UPDATE_CREDIT_CARD_HISTORY', cardlossofs.body.appBody);
                    } else {
                        this.$store.commit('common/UPDATE_CREDIT_CARD_HISTORY', {});
                        // let ErrorMessage = '错误码：'+cardlossofs.sysHead.rspCd+' '+'错误信息：'+cardlossofs.sysHead.rspMsg;
                        // this.$alert(ErrorMessage, cardlossofs.sysHead.busiName, {
                        //     customClass: 'error'
                        // })
                    }
                }
            });
        },

        handelmainleft() {
            const DomLeft = this.$refs.businessSystem_left;
            const DomRight = this.$refs.businessSystem_right;
            if (this.rightBtnClass) {
                this.$refs.mainLeft.style.display = 'block';
                DomLeft.style.width = '23%';
                DomLeft.style.height = '100%';
                DomLeft.style.paddingLeft = '15px';
                // DomRight.style.width="76%";
                DomLeft.style.minWidth = '250px';
                this.rightBtnClass = false;
            } else {
                this.$refs.mainLeft.style.display = 'none';
                DomLeft.style.width = '20px';
                DomLeft.style.minWidth = '20px';
                DomLeft.style.height = '85vh';
                DomLeft.style.paddingLeft = '0px';
                // DomRight.style.width="97%";
                this.rightBtnClass = true;
            }
        },
        // 重置
        remove() {
            this.formData.offlinetablecardnbr = '';
            this.formData.keytype = '01';
            this.formData.offlinetablecustid = '';
            // this.formData.grantreason = '123';
        },

        get3077() {

            const appBody = {
                CARDNBR: this.cardInfo_3004.CARDNO, // 卡号
                // 空或Z：全部  A：灵活分期 C：信用计划分期 B：余额转移 H：银联POS分期 L：大额分期 M：邮购分期  P：自行POS分期 S：深圳银联POS分期 Y：余额/账单分期 D：自动分期
                MPTYPE: '', // 分期付款类型
                OPERCODE: '0', // 操作代码  0全部返回  1可提前还款的分期交易    2可撤销的分期交易
                OPT: '1', // 查询方式 1-用卡号查询 2-用证件号码查询
                //CATE: this.accountType, // 账户类别 查询方式为2时，必填
                PINFLAG: '', // 是否检查密码标志
                BEGDAY: this.startDate, // 起始日期
                ENDDAY: this.endDate, // 结束日期 
                RTNIND: this.RtnindFlag,// 翻页标志 首次传空， 翻页传1
                NEXTDAY: this.NEXTDAY_3077,// 首次查询时送查询起始日期， 下翻页查询时上送上次查询结果的最后一条记录返回的分期付款交易日期
                NEXTMPNO: this.NEXTMPNO_3077,// 首次查询时送起始序号，默认为0 下翻页查询时上送上次查询结果的最后一条记录返回的交易序号
            };

            const defaultParams = JSON.parse(JSON.stringify(this.defaultParams));
            defaultParams.body.appHead.tranCode = '3077';
            defaultParams.body.appBody = appBody;
            // 3077交易
            //console.log("this.appBody3077***********", appBody);
            this.$post.common.transPort(defaultParams).then((res) => {
                if (res.status === 200) {
                    const result = JSON.parse(res.data.jsonRes);
                    if (result.sysHead.rspCd === '000000') {
                        //console.log("this.result3077***********", result);
                        this.mpappnum = parseInt(this.mpappnum) + result.body.appBody.dataList.length;
                        this.NEXTDAY_3077 = result.body.appBody.dataList[result.body.appBody.dataList.length - 1].BEGYM;
                        this.NEXTMPNO_3077 = result.body.appBody.dataList[result.body.appBody.dataList.length - 1].MPNO;
                        // 修改翻页标志 
                        this.RtnindFlag = result.body.appBody.RTNIND;
                        if (result.body.appBody.RTNIND === '1') {
                            this.get3077();
                            // console.log("this.mpappnum", this.mpappnum);
                        }
                    }
                }
            });
        },
        // 4017
        async get4017() {
            console.log('4017交易');
            //  配置请求头
            const appBody_4017 = {
                CARDNBR: this.cardInfo_3004.CARDNO || '', // 卡号
                FLAG: '1',
                CURRNUM: '156',
                PINFLAG: this.defaultpinFlag,
                CHECNKFLG: '000000000000000',
            };
            const defaultParams_4017 = JSON.parse(JSON.stringify(this.defaultParams));
            defaultParams_4017.body.appHead.tranCode = '4017';
            defaultParams_4017.body.appBody = appBody_4017;
            await this.$post.common.transPort(defaultParams_4017).then((res) => {
                if (res.status === 200) {
                    const result = JSON.parse(res.data.jsonRes);
                    if (result.sysHead.rspCd === '000000') {
                        this.$store.commit('common/UPDATE_AUTOREPAY_ACCT', result.body.appBody);
                    }
                }
            });
        },
        trimCard() {
            let cardno = this.formData.offlinetablecardnbr;

            let newtxt = '';
            var i, s;
            for (i = 0; i < cardno.length; i++) {
                s = cardno.substr(i, 1);
                if (s != " ") {
                    newtxt = newtxt.concat(s);
                }
            }
            this.formData.offlinetablecardnbr = newtxt;
        },
        checkCard() {
            let cardno = this.formData.offlinetablecardnbr;
            let custid = this.formData.offlinetablecustid;
            if (cardno !== '' && custid.trim() !== '') {
                this.$alert('卡号和证件号码只能输入一个!', '提示', {
                    customClass: 'warning', type: 'warning',
                }); return;
            }
        },
    },
    // 销毁客户视图这个页面
    destroyed() {
        this.$store.commit('menu/UPDATA_SHOW_NAV_HEAD', false);
    },
};
</script>
<style lang="css" lang='scss'>
.isrighticon i.el-icon-d-arrow-left {
    -webkit-transform: rotateZ(180deg);
    transform: rotateZ(180deg);
}
.businessSystem-right {
    .cardComponent {
        padding-bottom: 5px;
    }
    .rightMain {
        .el-card .el-card__header {
            padding: 8px 20px;
        }
        .container .tsinput .el-input.el-input--suffix {
            width: 100%;
        }
    }
}
</style>
<style lang='scss' scoped>
.businessSystem-container {
    /* padding-top: 8px; */
    overflow-x: auto;
    .businessSystem-wrap {
        height: 100%;
        min-width: 1050px;
        .businessSystem-left {
            position: relative;
            float: left;
            min-width: 250px;
            height: 100%;
            .businessSystem_mainLeft {
                height: 100%;
                overflow: hidden;
                overflow-y: auto;
                padding-right: 5px;
            }
            .btnright {
                position: absolute;
                width: 18px;
                padding: 20px 8px 20px 1px;
                margin-left: 2px;
                top: 35vh;
                right: 0;
            }
        }
        .businessSystem-right {
            /* min-width: 800px;
            height: 100%;
            width: 76%;
            display: inline-block; */
            min-width: 800px;
            height: 100%;
            .rightMain {
                min-height: 220px;
                margin-bottom: 5px;
            }
        }
    }
}

.app-main-container .app-main {
    padding: 10px 20px 20px;
}

.el-form-item__content .el-input__inner,
.el-select {
    width: 100%;
}

.item_right {
    padding-left: 5%;
    line-height: 95px;
}
.text_fl {
    text-align: left;
}
/* 调整下拉菜单样式 */
/* body > .el-menu--horizontal > ul > .navMenu_head {
    a li.el-menu-item {
        font-size: 14px;    
    }
    a li.el-menu-item:hover {
        background-color: #69c5ff;
        // color:#fff;
    }
}
body
    > .el-menu--horizontal
    > ul
    > .navMenu_head
    > li.el-submenu
    > .el-submenu__title:hover {
    background-color: #69c5ff;
} */
</style>
